package com.yxw.yxnet_cd_center.customer_service.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yxw.yxnet_cd_center.common.dto.PageVO;
import com.yxw.yxnet_cd_center.common.exception.BaseException;
import com.yxw.yxnet_cd_center.customer_service.dto.CprDTO;
import com.yxw.yxnet_cd_center.customer_service.dto.CprQueryDTO;
import com.yxw.yxnet_cd_center.customer_service.entity.YxCsProblemLibEntity;
import com.yxw.yxnet_cd_center.customer_service.mapper.CprMapper;
import com.yxw.yxnet_cd_center.customer_service.service.ICprService;
import com.yxw.yxnet_cd_center.customer_service.utils.PageUtils;
import com.yxw.yxnet_cd_center.customer_service.utils.UserUtil;
import com.yxw.yxnet_cd_center.customer_service.vo.CprVO;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

/**
 * 常见问题管理Service业务层处理
 *
 * @author xiexuxin
 * @date 2023-09-21
 */
@Slf4j
@Service
public class CprServiceImpl extends ServiceImpl<CprMapper, YxCsProblemLibEntity> implements ICprService {

    @Autowired
    private CprMapper cprMapper;

    @Autowired
    private UserUtil userUtil;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void addCpr(CprDTO cprDTO) {
        log.info("开始处理添加常见问题的业务，参数：{}", cprDTO);
        // 创建问题库实体对象
        YxCsProblemLibEntity problemLib = new YxCsProblemLibEntity();
        BeanUtils.copyProperties(cprDTO, problemLib);
        // 获取已有的问题列表
        List<CprVO> list = cprMapper.cprList();
        if (list != null && !list.isEmpty()) {
            CprVO firstCpr = list.get(0);
            problemLib.setChannelName(firstCpr.getChannelName());
        }
        if (userUtil.getLoginUserVo() != null){
            String username = userUtil.getLoginUserVo().getUserName();
            problemLib.setLibName(username);
        }
        problemLib.setLibType(1);
        problemLib.setCreateTime(LocalDateTime.now());
        // 插入问题库数据
        int rows = cprMapper.insert(problemLib);
        if (rows != 1) {
            throw new BaseException("添加问题失败，服务器忙，请稍后再尝试！");
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteCprById(Long problemLibId) {
        log.info("开始处理【删除常见问题】的业务，参数：{}", problemLibId);
        // 查询要删除的问题数据
        CprVO queryResult = selectCprById(problemLibId);
        // 判断要删除的问题数据是否存在
        if (queryResult == null || queryResult.getProblemLibId() == 0) {
            throw new BaseException("删除问题失败，尝试删除的问题数据不存在！");
        }
        // 执行删除操作
        int rows = cprMapper.deleteCprById(problemLibId);
        // 判断删除操作是否成功
        if (rows != 1) {
            throw new BaseException("删除问题失败，服务器忙，请稍后再试！");
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteCprByIds(List<Long> problemLibIds) {
        log.info("开始处理【批量删除常见问题】的业务，参数：{}", problemLibIds);
        // 判断要删除的问题数据是否存在
        if (problemLibIds == null || problemLibIds.isEmpty()) {
            throw new BaseException("删除问题失败，尝试删除的问题数据不存在！");
        }
        // 执行批量删除操作
        int rows = cprMapper.deleteCprByIds(problemLibIds);
        // 判断删除操作是否成功
        if (rows != problemLibIds.size()) {
            throw new BaseException("删除问题失败，服务器忙，请稍后再试！");
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateCpr(Long problemLibId, CprDTO cprDTO) {
        log.info("开始处理【修改常见问题】的业务，参数：{}", cprDTO);
        // 根据问题ID查询要修改的问题对象
        CprVO queryResult = cprMapper.selectCprById(problemLibId);
        // 判断要修改的问题数据是否存在
        if (queryResult == null || queryResult.getProblemLibId() == 0) {
            throw new BaseException("修改问题失败，尝试修改的问题数据不存在！");
        }
        // 创建要更新的问题实体对象，并将属性从DTO复制过来
        YxCsProblemLibEntity cprEntity = new YxCsProblemLibEntity();
        BeanUtils.copyProperties(cprDTO, cprEntity);
        cprEntity.setProblemLibId(problemLibId);
        cprEntity.setUpdateTime(LocalDateTime.now());
        // 执行更新操作
        int rows = cprMapper.updateById(cprEntity);
        // 判断更新操作是否成功
        if (rows != 1) {
            throw new BaseException("修改问题失败，服务器忙，请稍后再试！");
        }
    }

    @Override
    public CprVO selectCprById(Long problemLibId) {
        log.info("开始处理【根据id查询常见问题】的业务，参数：{}", problemLibId);
        return cprMapper.selectCprById(problemLibId);
    }

    @Override
    public PageVO<CprVO> getCprList(CprQueryDTO cprQueryDTO) {
        log.info("开始处理【条件查询常见问题列表】的业务，条件参数：{}", cprQueryDTO);
        Page<CprVO> page = new Page<>(cprQueryDTO.getCurrPage(), cprQueryDTO.getPageSize());
        List<CprVO> list = cprMapper.getCprList(page,cprQueryDTO);
        for (CprVO cpr : list) {
            // 获取问题库ID、回复率、渠道名称、渠道编码和模块名称
            Long problemLibId = cpr.getProblemLibId();
            String replyRate = cpr.getReplyRate();
            String channelName = cpr.getChannelName();
            Long channelId = cpr.getChannelId();
            // 调用updateReplyRate方法进行相关操作
            updateReplyRate(problemLibId, replyRate, channelName, channelId);
        }
        return PageUtils.get(page, list);
    }

    @Override
    public PageVO<CprVO> cprList() {
        log.info("开始处理【查询常见问题列表】的业务，无参数");
        // 获取当前页码和每页记录数
        CprQueryDTO crpQueryDTO = new CprQueryDTO();
        int currPage = crpQueryDTO.getCurrPage();
        int pageSize = crpQueryDTO.getPageSize();
        Page<CprVO> page = new Page<>(currPage, pageSize);
        // 获取常见问题列表的数据
        List<CprVO> list = cprMapper.cprList();
        // 计算总记录数和总页数
        int total = list.size();
        long totalPages = (total + pageSize - 1) / pageSize;
        // 设置总记录数和总页数
        page.setTotal(total);
        page.setPages(totalPages);
        // 使用PageUtils工具类将分页对象和列表数据封装成PageVO对象并返回
        return PageUtils.get(page, list);
    }

    @Transactional(rollbackFor = Exception.class)
    public void updateReplyRate(Long problemLibId, String replyRate, String channelName, Long channelId) {
        // 根据问题库ID从数据库中获取对应的问题库实体对象
        YxCsProblemLibEntity problemLib = cprMapper.selectById(problemLibId);
        // 设置回复率、渠道名称、渠道代码和模块名称
        problemLib.setReplyRate(replyRate);
        problemLib.setChannelName(channelName);
        problemLib.setChannelId(channelId);
        // 调用cprMapper的updateById方法更新问题库实体对象到数据库中
        cprMapper.updateById(problemLib);
    }

    @Override
    public List<CprVO> cprList(String replyDes) {
        log.info("开始处理【根据问题回复查询常见问题列表】的业务，参数:{}", replyDes);
        // 设置查询条件
        YxCsProblemLibEntity entity = new YxCsProblemLibEntity();
        LambdaQueryWrapper<YxCsProblemLibEntity> queryWrapper = new LambdaQueryWrapper<>(entity);
        queryWrapper
                .like(StringUtils.isNotBlank(replyDes), YxCsProblemLibEntity::getReplyDes, replyDes)
                .eq(YxCsProblemLibEntity::getLibType, 1);
        // 执行查询操作
        List<YxCsProblemLibEntity> entityList = baseMapper.selectList(queryWrapper);
        List<CprVO> listVoList = new ArrayList<>();
        // 判断实体对象列表是否为空,将实体对象列表转换为CprVO对象列表
        if (entityList != null && !entityList.isEmpty()) {
            listVoList = BeanUtil.copyToList(entityList, CprVO.class);
        }
        // 返回CprVO对象列表
        return listVoList;
    }
}
